// Step 3: Recalculate item numbers and start times using stored gaps
 let itemCount = 1;
 let cumulativeEndTimeSeconds = firstAnchoredStart;
 
 const recalculatedItems = itemsWithGaps.map((item) => {
   if (item.type === "header") {
     const existingStartTime = parseTimeToSeconds(item.startTime || "");
     let newHeaderStart: string;
 
     if (existingStartTime !== null) {
-      // Advance pointer to header time if it's ahead, clamp if behind
       if (existingStartTime > cumulativeEndTimeSeconds) {
         cumulativeEndTimeSeconds = existingStartTime;
         newHeaderStart = item.startTime!;
       } else {
         newHeaderStart = formatSecondsToTime(cumulativeEndTimeSeconds);
       }
     } else {
       newHeaderStart = formatSecondsToTime(cumulativeEndTimeSeconds);
     }
 
-    // Return header without calculatedGap property
     return {
       id: item.id,
       type: item.type,
-      itemNumber: item.itemNumber,
+      itemNumber: "", // keep headers unnumbered to avoid conflicts
       startTime: newHeaderStart,
       highlightColor: item.highlightColor,
       headerTitle: item.headerTitle,
     } as RunOfShowItem;
   }
 
-  // Items - extract gap and other properties
   const itemWithGap = item as RunOfShowItem & { calculatedGap?: number };
   const gap = itemWithGap.calculatedGap || 0;
   const newStartTime = cumulativeEndTimeSeconds + gap;
   const durationSeconds = parseDurationToSeconds(item.duration || "");
 
-  itemCount++;
+  const currentItemNumber = itemCount.toString();
+  // advance pointers after assigning the current number
   cumulativeEndTimeSeconds = newStartTime;
   if (durationSeconds !== null) {
     cumulativeEndTimeSeconds += durationSeconds;
   }
+  itemCount++;
 
-  // Return item without calculatedGap property
   return {
     id: item.id,
     type: item.type,
-    itemNumber: itemCount.toString(),
+    itemNumber: currentItemNumber,
     startTime: formatSecondsToTime(newStartTime),
     highlightColor: item.highlightColor,
     preset: item.preset,
     duration: item.duration,
     privateNotes: item.privateNotes,
     productionNotes: item.productionNotes,
     audio: item.audio,
     video: item.video,
     lights: item.lights,
-    // Include custom column values
     ...Object.keys(item)
       .filter(
         (key) =>
           ![
             "id",
             "type",
             "itemNumber",
             "startTime",
             "highlightColor",
             "preset",
             "duration",
             "privateNotes",
             "productionNotes",
             "audio",
             "video",
             "lights",
             "calculatedGap",
             "headerTitle",
           ].includes(key),
       )
       .reduce(
         (acc, key) => {
           acc[key] = item[key as keyof RunOfShowItem];
           return acc;
         },
         {} as Record<string, string | number | boolean | undefined>,
       ),
   } as RunOfShowItem;
 });

-// Establish initial cumulative time from earliest anchored start (header or item)
+// Establish initial cumulative time from earliest anchored start based on items only
 const firstAnchoredStart = (() => {
   for (const it of itemsWithGaps) {
+    if (it.type !== "item") continue;
     const t = parseTimeToSeconds(it.startTime || "");
     if (t !== null) return t;
   }
   return 0;
 })();

-// Step 1: Calculate gaps BEFORE reordering
-// This captures the gap each item has relative to its IMMEDIATE previous item
 const itemsWithGaps = items.map((item, index) => {
   let gap = 0;
 
   if (item.type === "item") {
     const itemStartTime = parseTimeToSeconds(item.startTime || "");
-
-    if (itemStartTime === null) {
-      // Without a valid start time we cannot compute a reliable gap
+    if (itemStartTime === null || !Number.isFinite(itemStartTime)) {
       return { ...item, calculatedGap: 0 };
     }
 
-    // Walk backwards to find the previous item's end time, skipping headers
     let prevEndTime: number | null = null;
     for (let i = index - 1; i >= 0; i--) {
       const prev = items[i];
       if (prev.type !== "item") continue;
 
       const prevStart = parseTimeToSeconds(prev.startTime || "");
-      const prevDuration = parseDurationToSeconds(prev.duration || "");
+      const prevDurationParsed = parseDurationToSeconds(prev.duration || "");
+      const prevDurationSafe =
+        prevDurationParsed !== null && Number.isFinite(prevDurationParsed)
+          ? prevDurationParsed
+          : 0;
 
-      if (prevStart !== null) {
-        prevEndTime = prevStart + (prevDuration ?? 0);
+      if (prevStart !== null && Number.isFinite(prevStart)) {
+        const end = prevStart + prevDurationSafe;
+        prevEndTime = Number.isFinite(end) ? end : prevStart; // fallback to start if something goes wrong
         break;
       }
-
-      // If no start, but we have duration, keep looking further back
-      // However, don't add duration without a known anchor start.
-      if (prevStart === null) continue;
     }
 
     if (prevEndTime !== null) {
-      gap = itemStartTime - prevEndTime;
-      if (gap < 0) gap = 0;
+      const rawGap = itemStartTime - prevEndTime;
+      gap = Number.isFinite(rawGap) && rawGap > 0 ? rawGap : 0;
     } else {
-      // No previous item with a valid start; treat as no gap to preserve
       gap = 0;
     }
   }
 
   return { ...item, calculatedGap: gap };
 });

 const recalculatedItems = itemsWithGaps.map((item) => {
   if (item.type === "header") {
     const existingStartTime = parseTimeToSeconds(item.startTime || "");
     let newHeaderStart: string;
 
-    if (existingStartTime !== null) {
-      // Advance pointer to header time if it's ahead, clamp if behind
-      if (existingStartTime > cumulativeEndTimeSeconds) {
-        cumulativeEndTimeSeconds = existingStartTime;
-        newHeaderStart = item.startTime!;
-      } else {
-        newHeaderStart = formatSecondsToTime(cumulativeEndTimeSeconds);
-      }
+    if (existingStartTime !== null && existingStartTime > cumulativeEndTimeSeconds) {
+      // Only advance pointer if header explicitly anchors to a future time
+      cumulativeEndTimeSeconds = existingStartTime;
+      newHeaderStart = item.startTime!;
     } else {
+      // Do not clamp backwards; keep header aligned to current pointer
       newHeaderStart = formatSecondsToTime(cumulativeEndTimeSeconds);
     }
 
-    // Return header without calculatedGap property
     return {
       id: item.id,
       type: item.type,
-      itemNumber: item.itemNumber,
+      itemNumber: "", // headers should not consume or display item numbers here
       startTime: newHeaderStart,
       highlightColor: item.highlightColor,
       headerTitle: item.headerTitle,
     } as RunOfShowItem;
   }
 
   // Items - extract gap and other properties
   const itemWithGap = item as RunOfShowItem & { calculatedGap?: number };
   const gap = itemWithGap.calculatedGap || 0;
   const newStartTime = cumulativeEndTimeSeconds + gap;
   const durationSeconds = parseDurationToSeconds(item.duration || "");
 
+  // Set number before increment to avoid off-by-one
+  const currentItemNumber = itemCount.toString();
   itemCount++;
+
   cumulativeEndTimeSeconds = newStartTime;
   if (durationSeconds !== null) {
     cumulativeEndTimeSeconds += durationSeconds;
   }
 
-  // Return item without calculatedGap property
   return {
     id: item.id,
     type: item.type,
-    itemNumber: itemCount.toString(),
+    itemNumber: currentItemNumber,
     startTime: formatSecondsToTime(newStartTime),
     highlightColor: item.highlightColor,
     preset: item.preset,
     duration: item.duration,
     privateNotes: item.privateNotes,
     productionNotes: item.productionNotes,
     audio: item.audio,
     video: item.video,
     lights: item.lights,
-    // Include custom column values
     ...Object.keys(item)
       .filter(
         (key) =>
           ![
             "id",
             "type",
             "itemNumber",
             "startTime",
             "highlightColor",
             "preset",
             "duration",
             "privateNotes",
             "productionNotes",
             "audio",
             "video",
             "lights",
             "calculatedGap",
             "headerTitle",
           ].includes(key),
       )
       .reduce(
         (acc, key) => {
           acc[key] = item[key as keyof RunOfShowItem];
           return acc;
         },
         {} as Record<string, string | number | boolean | undefined>,
       ),
   } as RunOfShowItem;
 });

 const itemsWithGaps = items.map((item, index) => {
   let gap = 0;
 
   if (item.type === "item") {
     const itemStartTime = parseTimeToSeconds(item.startTime || "");
 
     if (itemStartTime === null) {
       // Without a valid start time we cannot compute a reliable gap
       return { ...item, calculatedGap: 0 };
     }
 
-    // Walk backwards to find the previous item's end time, skipping headers
+    // Walk backwards to find an anchor start, accumulating durations
     let prevEndTime: number | null = null;
+    let accumulatedDurations = 0;
+
     for (let i = index - 1; i >= 0; i--) {
       const prev = items[i];
       if (prev.type !== "item") continue;
 
       const prevStart = parseTimeToSeconds(prev.startTime || "");
-      const prevDuration = parseDurationToSeconds(prev.duration || "");
+      const prevDuration = parseDurationToSeconds(prev.duration || "") ?? 0;
 
       if (prevStart !== null) {
-        prevEndTime = prevStart + (prevDuration ?? 0);
+        prevEndTime = prevStart + prevDuration + accumulatedDurations;
         break;
+      } else {
+        // No start; accumulate duration and continue searching for an earlier anchor
+        accumulatedDurations += prevDuration;
+        continue;
       }
-
-      // If no start, but we have duration, keep looking further back
-      // However, don't add duration without a known anchor start.
-      if (prevStart === null) continue;
     }
 
     if (prevEndTime !== null) {
       gap = itemStartTime - prevEndTime;
       if (gap < 0) gap = 0;
     } else {
-      // No previous item with a valid start; treat as no gap to preserve
       gap = 0;
     }
   }
 
   return { ...item, calculatedGap: gap };
 });